// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef IPC_IPC_MESSAGE_H_
#define IPC_IPC_MESSAGE_H_

#include <stddef.h>
#include <stdint.h>

#include <string>

#include "base/gtest_prod_util.h"
#include "base/memory/ref_counted.h"
#include "base/pickle.h"
#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "ipc/attachment_broker.h"
#include "ipc/brokerable_attachment.h"
#include "ipc/ipc_export.h"

#if !defined(NDEBUG)
#define IPC_MESSAGE_LOG_ENABLED
#endif

namespace IPC {

namespace internal {
    class ChannelReader;
} // namespace internal

//------------------------------------------------------------------------------

struct LogData;
class MessageAttachment;
class MessageAttachmentSet;

class IPC_EXPORT Message : public base::Pickle {
public:
    enum PriorityValue {
        PRIORITY_LOW = 1,
        PRIORITY_NORMAL,
        PRIORITY_HIGH
    };

    // Bit values used in the flags field.
    // Upper 24 bits of flags store a reference number, so this enum is limited to
    // 8 bits.
    enum {
        PRIORITY_MASK = 0x03, // Low 2 bits of store the priority value.
        SYNC_BIT = 0x04,
        REPLY_BIT = 0x08,
        REPLY_ERROR_BIT = 0x10,
        UNBLOCK_BIT = 0x20,
        PUMPING_MSGS_BIT = 0x40,
        HAS_SENT_TIME_BIT = 0x80,
    };

    ~Message() override;

    Message();

    // Initialize a message with a user-defined type, priority value, and
    // destination WebView ID.
    Message(int32_t routing_id, uint32_t type, PriorityValue priority);

    // Initializes a message from a const block of data.  The data is not copied;
    // instead the data is merely referenced by this message.  Only const methods
    // should be used on the message when initialized this way.
    Message(const char* data, int data_len);

    Message(const Message& other);
    Message& operator=(const Message& other);

    PriorityValue priority() const
    {
        return static_cast<PriorityValue>(header()->flags & PRIORITY_MASK);
    }

    // True if this is a synchronous message.
    void set_sync()
    {
        header()->flags |= SYNC_BIT;
    }
    bool is_sync() const
    {
        return (header()->flags & SYNC_BIT) != 0;
    }

    // Set this on a reply to a synchronous message.
    void set_reply()
    {
        header()->flags |= REPLY_BIT;
    }

    bool is_reply() const
    {
        return (header()->flags & REPLY_BIT) != 0;
    }

    // Set this on a reply to a synchronous message to indicate that no receiver
    // was found.
    void set_reply_error()
    {
        header()->flags |= REPLY_ERROR_BIT;
    }

    bool is_reply_error() const
    {
        return (header()->flags & REPLY_ERROR_BIT) != 0;
    }

    // Normally when a receiver gets a message and they're blocked on a
    // synchronous message Send, they buffer a message.  Setting this flag causes
    // the receiver to be unblocked and the message to be dispatched immediately.
    void set_unblock(bool unblock)
    {
        if (unblock) {
            header()->flags |= UNBLOCK_BIT;
        } else {
            header()->flags &= ~UNBLOCK_BIT;
        }
    }

    bool should_unblock() const
    {
        return (header()->flags & UNBLOCK_BIT) != 0;
    }

    // Tells the receiver that the caller is pumping messages while waiting
    // for the result.
    bool is_caller_pumping_messages() const
    {
        return (header()->flags & PUMPING_MSGS_BIT) != 0;
    }

    void set_dispatch_error() const
    {
        dispatch_error_ = true;
    }

    bool dispatch_error() const
    {
        return dispatch_error_;
    }

    uint32_t type() const
    {
        return header()->type;
    }

    int32_t routing_id() const
    {
        return header()->routing;
    }

    void set_routing_id(int32_t new_id)
    {
        header()->routing = new_id;
    }

    uint32_t flags() const
    {
        return header()->flags;
    }

    // Sets all the given header values. The message should be empty at this
    // call.
    void SetHeaderValues(int32_t routing, uint32_t type, uint32_t flags);

    template <class T, class S, class P>
    static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
        void (T::*func)())
    {
        (obj->*func)();
        return true;
    }

    template <class T, class S, class P>
    static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
        void (T::*func)(P*))
    {
        (obj->*func)(parameter);
        return true;
    }

    // Used for async messages with no parameters.
    static void Log(std::string* name, const Message* msg, std::string* l)
    {
    }

    // The static method FindNext() returns several pieces of information, which
    // are aggregated into an instance of this struct.
    struct IPC_EXPORT NextMessageInfo {
        NextMessageInfo();
        ~NextMessageInfo();

        // Total message size. Always valid if |message_found| is true.
        // If |message_found| is false but we could determine message size
        // from the header, this field is non-zero. Otherwise it's zero.
        size_t message_size;
        // Whether an entire message was found in the given memory range.
        bool message_found;
        // Only filled in if |message_found| is true.
        // The start address is passed into FindNext() by the caller, so isn't
        // repeated in this struct. The end address of the pickle should be used to
        // construct a base::Pickle.
        const char* pickle_end;
        // Only filled in if |message_found| is true.
        // The end address of the message should be used to determine the start
        // address of the next message.
        const char* message_end;
        // If the message has brokerable attachments, this vector will contain the
        // ids of the brokerable attachments. The caller of FindNext() is
        // responsible for adding the attachments to the message.
        std::vector<BrokerableAttachment::AttachmentId> attachment_ids;
    };

    struct SerializedAttachmentIds {
        void* buffer;
        size_t size;
    };
    // Creates a buffer that contains a serialization of the ids of the brokerable
    // attachments of the message. This buffer is intended to be sent over the IPC
    // channel immediately after the pickled message. The caller takes ownership
    // of the buffer.
    // This method should only be called if the message has brokerable
    // attachments.
    SerializedAttachmentIds SerializedIdsOfBrokerableAttachments();

    // |info| is an output parameter and must not be nullptr.
    static void FindNext(const char* range_start,
        const char* range_end,
        NextMessageInfo* info);

    // Adds a placeholder brokerable attachment that must be replaced before the
    // message can be dispatched.
    bool AddPlaceholderBrokerableAttachmentWithId(
        BrokerableAttachment::AttachmentId id);

    // WriteAttachment appends |attachment| to the end of the set. It returns
    // false iff the set is full.
    bool WriteAttachment(
        scoped_refptr<base::Pickle::Attachment> attachment) override;
    // ReadAttachment parses an attachment given the parsing state |iter| and
    // writes it to |*attachment|. It returns true on success.
    bool ReadAttachment(
        base::PickleIterator* iter,
        scoped_refptr<base::Pickle::Attachment>* attachment) const override;
    // Returns true if there are any attachment in this message.
    bool HasAttachments() const override;
    // Returns true if there are any MojoHandleAttachments in this message.
    bool HasMojoHandles() const;
    // Whether the message has any brokerable attachments.
    bool HasBrokerableAttachments() const;

    void set_sender_pid(base::ProcessId id) { sender_pid_ = id; }
    base::ProcessId get_sender_pid() const { return sender_pid_; }

#ifdef IPC_MESSAGE_LOG_ENABLED
    // Adds the outgoing time from Time::Now() at the end of the message and sets
    // a bit to indicate that it's been added.
    void set_sent_time(int64_t time);
    int64_t sent_time() const;

    void set_received_time(int64_t time) const;
    int64_t received_time() const { return received_time_; }
    void set_output_params(const std::string& op) const { output_params_ = op; }
    const std::string& output_params() const { return output_params_; }
    // The following four functions are needed so we can log sync messages with
    // delayed replies.  We stick the log data from the sent message into the
    // reply message, so that when it's sent and we have the output parameters
    // we can log it.  As such, we set a flag on the sent message to not log it.
    void set_sync_log_data(LogData* data) const { log_data_ = data; }
    LogData* sync_log_data() const { return log_data_; }
    void set_dont_log() const { dont_log_ = true; }
    bool dont_log() const { return dont_log_; }
#endif

protected:
    friend class Channel;
    friend class ChannelMojo;
    friend class ChannelNacl;
    friend class ChannelPosix;
    friend class ChannelWin;
    friend class internal::ChannelReader;
    friend class MessageReplyDeserializer;
    friend class SyncMessage;

#pragma pack(push, 4)
    struct Header : base::Pickle::Header {
        int32_t routing; // ID of the view that this message is destined for
        uint32_t type; // specifies the user-defined message type
        uint32_t flags; // specifies control flags for the message
#if USE_ATTACHMENT_BROKER
        // The number of brokered attachments included with this message. The
        // ids of the brokered attachment ids are sent immediately after the pickled
        // message, before the next pickled message is sent.
        uint32_t num_brokered_attachments;
#endif
#if defined(OS_POSIX)
        uint16_t num_fds; // the number of descriptors included with this message
        uint16_t pad; // explicitly initialize this to appease valgrind
#endif
    };
#pragma pack(pop)

    Header* header()
    {
        return headerT<Header>();
    }
    const Header* header() const
    {
        return headerT<Header>();
    }

    void Init();

    // Used internally to support IPC::Listener::OnBadMessageReceived.
    mutable bool dispatch_error_;

    // The set of file descriptors associated with this message.
    scoped_refptr<MessageAttachmentSet> attachment_set_;

    // Ensure that a MessageAttachmentSet is allocated
    void EnsureMessageAttachmentSet();

    MessageAttachmentSet* attachment_set()
    {
        EnsureMessageAttachmentSet();
        return attachment_set_.get();
    }
    const MessageAttachmentSet* attachment_set() const
    {
        return attachment_set_.get();
    }

    // The process id of the sender of the message. This member is populated with
    // a valid value for every message dispatched to listeners.
    base::ProcessId sender_pid_;

#ifdef IPC_MESSAGE_LOG_ENABLED
    // Used for logging.
    mutable int64_t received_time_;
    mutable std::string output_params_;
    mutable LogData* log_data_;
    mutable bool dont_log_;
#endif

    FRIEND_TEST_ALL_PREFIXES(IPCMessageTest, FindNext);
    FRIEND_TEST_ALL_PREFIXES(IPCMessageTest, FindNextOverflow);
};

//------------------------------------------------------------------------------

} // namespace IPC

enum SpecialRoutingIDs {
    // indicates that we don't have a routing ID yet.
    MSG_ROUTING_NONE = -2,

    // indicates a general message not sent to a particular tab.
    MSG_ROUTING_CONTROL = INT32_MAX,
};

#define IPC_REPLY_ID 0xFFFFFFF0 // Special message id for replies
#define IPC_LOGGING_ID 0xFFFFFFF1 // Special message id for logging

#endif // IPC_IPC_MESSAGE_H_
